<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>Title</title>
    <style>

        html,body{
            width:100%;
            height:100%;
            display: flex;
            justify-content: center;
            align-items: center;
        }
        .collapse:not(.show) {
            display: none;
        }

        .collapsing {
            position: relative;
            height: 0;
            overflow: hidden;
            transition: height 0.35s ease;
        }
        .card-header{
            background-color: #ffa25d;
        }
    </style>
</head>
<body>
<button id="btn">click</button>
<div id="accordion">
    <div class="card">
        <div class="card-header">
            <a class="card-link" data-toggle="collapse" href="#collapseOne">
                选项一
            </a>
        </div>
        <div id="collapseOne" class="collapse show" data-parent="#accordion">
            <div class="card-body">
                1
            </div>
        </div>
    </div>
    <div class="card">
        <div class="card-header">
            <a class="collapsed card-link" data-toggle="collapse" href="#collapseTwo">
                选项二
            </a>
        </div>
        <div id="collapseTwo" class="collapse" data-parent="#accordion">
            <div class="card-body">
                2
            </div>
        </div>
    </div>
    <div class="card">
        <div class="card-header">
            <a class="collapsed card-link" data-toggle="collapse" href="#collapseThree">
                选项三
            </a>
        </div>
        <div id="collapseThree" class="collapse" data-parent="#accordion">
            <div class="card-body">
                3
            </div>
        </div>
    </div>
</div>
<script src="https://cdn.bootcss.com/jquery/3.2.1/jquery.min.js"></script>
<script>
    function _defineProperties(target, props) {
        for (var i = 0; i < props.length; i++) {
            var descriptor = props[i];
            descriptor.enumerable = descriptor.enumerable || false;
            descriptor.configurable = true;
            if ("value" in descriptor) descriptor.writable = true;
            Object.defineProperty(target, descriptor.key, descriptor);
        }
    }

    function _createClass(Constructor, protoProps, staticProps) {
        if (protoProps) _defineProperties(Constructor.prototype, protoProps);
        if (staticProps) _defineProperties(Constructor, staticProps);
        return Constructor;
    }

    function _defineProperty(obj, key, value) {
        if (key in obj) {
            Object.defineProperty(obj, key, {
                value: value,
                enumerable: true,
                configurable: true,
                writable: true
            });
        } else {
            obj[key] = value;
        }

        return obj;
    }

    function _objectSpread(target) {
        for (var i = 1; i < arguments.length; i++) {
            var source = arguments[i] != null ? arguments[i] : {};
            var ownKeys = Object.keys(source);

            if (typeof Object.getOwnPropertySymbols === 'function') {
                ownKeys = ownKeys.concat(Object.getOwnPropertySymbols(source).filter(function (sym) {
                    return Object.getOwnPropertyDescriptor(source, sym).enumerable;
                }));
            }

            ownKeys.forEach(function (key) {
                _defineProperty(target, key, source[key]);
            });
        }

        return target;
    }

    var Util = function ($$$1) {
        /**
         * ------------------------------------------------------------------------
         * Private TransitionEnd Helpers
         * ------------------------------------------------------------------------
         */
        var TRANSITION_END = 'transitionend';
        var MAX_UID = 1000000;
        var MILLISECONDS_MULTIPLIER = 1000; // Shoutout AngusCroll (https://goo.gl/pxwQGp)

        function toType(obj) {
            return {}.toString.call(obj).match(/\s([a-z]+)/i)[1].toLowerCase();
        }

        function getSpecialTransitionEndEvent() {
            return {
                bindType: TRANSITION_END,
                delegateType: TRANSITION_END,
                handle: function handle(event) {
                    if ($$$1(event.target).is(this)) {
                        return event.handleObj.handler.apply(this, arguments); // eslint-disable-line prefer-rest-params
                    }

                    return undefined; // eslint-disable-line no-undefined
                }
            };
        }

        function transitionEndEmulator(duration) {
            var _this = this;

            var called = false;
            $$$1(this).one(Util.TRANSITION_END, function () {
                called = true;
            });
            setTimeout(function () {
                if (!called) {
                    Util.triggerTransitionEnd(_this);
                }
            }, duration);
            return this;
        }

        function setTransitionEndSupport() {
            $$$1.fn.emulateTransitionEnd = transitionEndEmulator;
            $$$1.event.special[Util.TRANSITION_END] = getSpecialTransitionEndEvent();
        }
        /**
         * --------------------------------------------------------------------------
         * Public Util Api
         * --------------------------------------------------------------------------
         */


        var Util = {
            TRANSITION_END: 'bsTransitionEnd',
            getUID: function getUID(prefix) {
                do {
                    // eslint-disable-next-line no-bitwise
                    prefix += ~~(Math.random() * MAX_UID); // "~~" acts like a faster Math.floor() here
                } while (document.getElementById(prefix));

                return prefix;
            },

            //获取 target $ele
            getSelectorFromElement: function getSelectorFromElement(element) {
                var selector = element.getAttribute('data-target');

                if (!selector || selector === '#') {
                    selector = element.getAttribute('href') || '';
                }

                try {
                    var $selector = $$$1(document).find(selector);
                    return $selector.length > 0 ? selector : null;
                } catch (err) {
                    return null;
                }
            },

            //获取 css transition-duration
            getTransitionDurationFromElement: function getTransitionDurationFromElement(element) {
                if (!element) {
                    return 0;
                } // Get transition-duration of the element


                var transitionDuration = $$$1(element).css('transition-duration');
                var floatTransitionDuration = parseFloat(transitionDuration); // Return 0 if element or transition duration is not found

                if (!floatTransitionDuration) {
                    return 0;
                } // If multiple durations are defined, take the first


                transitionDuration = transitionDuration.split(',')[0];
                return parseFloat(transitionDuration) * MILLISECONDS_MULTIPLIER;
            },
            reflow: function reflow(element) {
                return element.offsetHeight;
            },
            triggerTransitionEnd: function triggerTransitionEnd(element) {
                $$$1(element).trigger(TRANSITION_END);
            },
            // TODO: Remove in v5
            supportsTransitionEnd: function supportsTransitionEnd() {
                return Boolean(TRANSITION_END);
            },
            isElement: function isElement(obj) {
                return (obj[0] || obj).nodeType;
            },
            typeCheckConfig: function typeCheckConfig(componentName, config, configTypes) {
                for (var property in configTypes) {
                    if (Object.prototype.hasOwnProperty.call(configTypes, property)) {
                        var expectedTypes = configTypes[property];
                        var value = config[property];
                        var valueType = value && Util.isElement(value) ? 'element' : toType(value);

                        if (!new RegExp(expectedTypes).test(valueType)) {
                            throw new Error(componentName.toUpperCase() + ": " + ("Option \"" + property + "\" provided type \"" + valueType + "\" ") + ("but expected type \"" + expectedTypes + "\"."));
                        }
                    }
                }
            }
        };
        setTransitionEndSupport();
        return Util;
    }($);


    var Collapse = function ($$$1) {
        /**
         * ------------------------------------------------------------------------
         * Constants
         * ------------------------------------------------------------------------
         */
        var NAME = 'collapse';
        var VERSION = '4.1.1';
        var DATA_KEY = 'bs.collapse';
        var EVENT_KEY = "." + DATA_KEY;
        var DATA_API_KEY = '.data-api';
        var JQUERY_NO_CONFLICT = $$$1.fn[NAME];
        var Default = {
            toggle: true,
            parent: ''
        };
        var DefaultType = {
            toggle: 'boolean',
            parent: '(string|element)'
        };
        var Event = {
            SHOW: "show" + EVENT_KEY,
            SHOWN: "shown" + EVENT_KEY,
            HIDE: "hide" + EVENT_KEY,
            HIDDEN: "hidden" + EVENT_KEY,
            CLICK_DATA_API: "click" + EVENT_KEY + DATA_API_KEY
        };
        var ClassName = {
            SHOW: 'show',
            COLLAPSE: 'collapse',
            COLLAPSING: 'collapsing',
            COLLAPSED: 'collapsed'
        };
        var Dimension = {
            WIDTH: 'width',
            HEIGHT: 'height'
        };
        var Selector = {
            ACTIVES: '.show, .collapsing',
            DATA_TOGGLE: '[data-toggle="collapse"]'
            /**
             * ------------------------------------------------------------------------
             * Class Definition
             * ------------------------------------------------------------------------
             */

        };

        var Collapse =
          /*#__PURE__*/
          function () {
              function Collapse(element, config) {
                  this._isTransitioning = false;
                  this._element = element;
                  this._config = this._getConfig(config);
                  this._triggerArray = $$$1.makeArray($$$1("[data-toggle=\"collapse\"][href=\"#" + element.id + "\"]," + ("[data-toggle=\"collapse\"][data-target=\"#" + element.id + "\"]")));
                  var tabToggles = $$$1(Selector.DATA_TOGGLE);

                  for (var i = 0; i < tabToggles.length; i++) {
                      var elem = tabToggles[i];
                      var selector = Util.getSelectorFromElement(elem);

                      if (selector !== null && $$$1(selector).filter(element).length > 0) {
                          this._selector = selector;

                          this._triggerArray.push(elem);
                      }
                  }


                  this._parent = this._config.parent ? this._getParent() : null;

                  if (!this._config.parent) {
                      this._addAriaAndCollapsedClass(this._element, this._triggerArray);
                  }

                  if (this._config.toggle) {
                      this.toggle();
                  }
              } // Getters


              var _proto = Collapse.prototype;

              // Public
              _proto.toggle = function toggle() {
                  if ($$$1(this._element).hasClass(ClassName.SHOW)) {
                      this.hide();
                  } else {
                      this.show();
                  }
              };

              _proto.show = function show() {
                  var _this = this;

                  if (this._isTransitioning || $$$1(this._element).hasClass(ClassName.SHOW)) {
                      return;
                  }

                  var actives;
                  var activesData;

                  // if (this._parent) {
                  //     actives = $$$1.makeArray($$$1(this._parent).find(Selector.ACTIVES).filter("[data-parent=\"" + this._config.parent + "\"]"));
                  //
                  //     if (actives.length === 0) {
                  //         actives = null;
                  //     }
                  // }
                  //
                  // if (actives) {
                  //     activesData = $$$1(actives).not(this._selector).data(DATA_KEY);
                  //
                  //     if (activesData && activesData._isTransitioning) {
                  //         return;
                  //     }
                  // }
                  //
                  // var startEvent = $$$1.Event(Event.SHOW);
                  // $$$1(this._element).trigger(startEvent);
                  //
                  // if (startEvent.isDefaultPrevented()) {
                  //     return;
                  // }
                  //
                  // if (actives) {
                  //     Collapse._jQueryInterface.call($$$1(actives).not(this._selector), 'hide');
                  //
                  //     if (!activesData) {
                  //         $$$1(actives).data(DATA_KEY, null);
                  //     }
                  // }

                  var dimension = this._getDimension();

                  $$$1(this._element).removeClass(ClassName.COLLAPSE).addClass(ClassName.COLLAPSING);
                  this._element.style[dimension] = 0;

                  // if (this._triggerArray.length > 0) {
                  //     $$$1(this._triggerArray).removeClass(ClassName.COLLAPSED).attr('aria-expanded', true);
                  // }

                  this.setTransitioning(true);

                  var complete = function complete() {
                      $$$1(_this._element).removeClass(ClassName.COLLAPSING).addClass(ClassName.COLLAPSE).addClass(ClassName.SHOW);
                      _this._element.style[dimension] = '';

                      _this.setTransitioning(false);

                      $$$1(_this._element).trigger(Event.SHOWN);
                  };

                  var capitalizedDimension = dimension[0].toUpperCase() + dimension.slice(1);
                  var scrollSize = "scroll" + capitalizedDimension;
                  var transitionDuration = Util.getTransitionDurationFromElement(this._element);
                  $$$1(this._element).one(Util.TRANSITION_END, complete).emulateTransitionEnd(transitionDuration);
                  this._element.style[dimension] = this._element[scrollSize] + "px";
              };

              _proto.hide = function hide() {
                  var _this2 = this;

                  if (this._isTransitioning || !$$$1(this._element).hasClass(ClassName.SHOW)) {
                      return;
                  }

                  var startEvent = $$$1.Event(Event.HIDE);
                  $$$1(this._element).trigger(startEvent);

                  if (startEvent.isDefaultPrevented()) {
                      return;
                  }

                  var dimension = this._getDimension();

                  this._element.style[dimension] = this._element.getBoundingClientRect()[dimension] + "px";
                  Util.reflow(this._element);
                  $$$1(this._element).addClass(ClassName.COLLAPSING).removeClass(ClassName.COLLAPSE).removeClass(ClassName.SHOW);

                  // if (this._triggerArray.length > 0) {
                  //     for (var i = 0; i < this._triggerArray.length; i++) {
                  //         var trigger = this._triggerArray[i];
                  //         var selector = Util.getSelectorFromElement(trigger);
                  //
                  //         if (selector !== null) {
                  //             var $elem = $$$1(selector);
                  //
                  //             if (!$elem.hasClass(ClassName.SHOW)) {
                  //                 $$$1(trigger).addClass(ClassName.COLLAPSED).attr('aria-expanded', false);
                  //             }
                  //         }
                  //     }
                  // }

                  this.setTransitioning(true);

                  var complete = function complete() {
                      _this2.setTransitioning(false);

                      $$$1(_this2._element).removeClass(ClassName.COLLAPSING).addClass(ClassName.COLLAPSE).trigger(Event.HIDDEN);
                  };

                  this._element.style[dimension] = '';
                  var transitionDuration = Util.getTransitionDurationFromElement(this._element);
                  $$$1(this._element).one(Util.TRANSITION_END, complete).emulateTransitionEnd(transitionDuration);
              };

              _proto.setTransitioning = function setTransitioning(isTransitioning) {
                  this._isTransitioning = isTransitioning;
              };

              _proto.dispose = function dispose() {
                  $$$1.removeData(this._element, DATA_KEY);
                  this._config = null;
                  this._parent = null;
                  this._element = null;
                  this._triggerArray = null;
                  this._isTransitioning = null;
              }; // Private


              _proto._getConfig = function _getConfig(config) {
                  config = _objectSpread({}, Default, config);
                  config.toggle = Boolean(config.toggle); // Coerce string values

                  Util.typeCheckConfig(NAME, config, DefaultType);
                  return config;
              };

              _proto._getDimension = function _getDimension() {
                  var hasWidth = $$$1(this._element).hasClass(Dimension.WIDTH);
                  return hasWidth ? Dimension.WIDTH : Dimension.HEIGHT;
              };

              //获取 data-parent 的 element
              //触发 collapse head 的 collapsed
              _proto._getParent = function _getParent() {
                  var _this3 = this;

                  var parent = null;

                  if (Util.isElement(this._config.parent)) {
                      parent = this._config.parent; // It's a jQuery object

                      if (typeof this._config.parent.jquery !== 'undefined') {
                          parent = this._config.parent[0];
                      }
                  } else {
                      parent = $$$1(this._config.parent)[0];
                  }

                  var selector = "[data-toggle=\"collapse\"][data-parent=\"" + this._config.parent + "\"]";
                  $$$1(parent).find(selector).each(function (i, element) {
                      _this3._addAriaAndCollapsedClass(Collapse._getTargetFromElement(element), [element]);
                  });
                  return parent;
              };

              _proto._addAriaAndCollapsedClass = function _addAriaAndCollapsedClass(element, triggerArray) {
                  if (element) {
                      var isOpen = $$$1(element).hasClass(ClassName.SHOW);

                      if (triggerArray.length > 0) {
                          $$$1(triggerArray).toggleClass(ClassName.COLLAPSED, !isOpen).attr('aria-expanded', isOpen);
                      }
                  }
              }; // Static


              Collapse._getTargetFromElement = function _getTargetFromElement(element) {
                  var selector = Util.getSelectorFromElement(element);
                  return selector ? $$$1(selector)[0] : null;
              };

              Collapse._jQueryInterface = function _jQueryInterface(config) {

                  return this.each(function () {

                      var $this = $$$1(this);
                      var data = $this.data(DATA_KEY);

                      var _config = _objectSpread({}, Default, $this.data(), typeof config === 'object' && config ? config : {});

                      if (!data && _config.toggle && /show|hide/.test(config)) {
                          _config.toggle = false;
                      }

                      if (!data) {
                          data = new Collapse(this, _config);
                          $this.data(DATA_KEY, data);
                      }

                      if (typeof config === 'string') {
                          if (typeof data[config] === 'undefined') {
                              throw new TypeError("No method named \"" + config + "\"");
                          }

                          data[config]();
                      }
                  });
              };

              _createClass(Collapse, null, [{
                  key: "VERSION",
                  get: function get() {
                      return VERSION;
                  }
              }, {
                  key: "Default",
                  get: function get() {
                      return Default;
                  }
              }]);

              return Collapse;
          }();
        /**
         * ------------------------------------------------------------------------
         * Data Api implementation
         * ------------------------------------------------------------------------
         */


        $$$1(document).on(Event.CLICK_DATA_API, Selector.DATA_TOGGLE, function (event) {
            // preventDefault only for <a> elements (which change the URL) not inside the collapsible element
            if (event.currentTarget.tagName === 'A') {
                event.preventDefault();
            }

            var $trigger = $$$1(this);
            var selector = Util.getSelectorFromElement(this);
            $$$1(selector).each(function () {
                var $target = $$$1(this);
                var data = $target.data(DATA_KEY);
                var config = data ? 'toggle' : $trigger.data();

                Collapse._jQueryInterface.call($target, config);
            });
        });
        /**
         * ------------------------------------------------------------------------
         * jQuery
         * ------------------------------------------------------------------------
         */

        $$$1.fn[NAME] = Collapse._jQueryInterface;
        $$$1.fn[NAME].Constructor = Collapse;

        $$$1.fn[NAME].noConflict = function () {
            $$$1.fn[NAME] = JQUERY_NO_CONFLICT;
            return Collapse._jQueryInterface;
        };

        return Collapse;
    }($);

    $("#btn").click(function(){
        console.log('click')
        $('#collapseOne').collapse('hide');
    })
</script>
</body>
</html>